Mac Easy 2010 May/Mac Life Ubuntu.iso/casper/filesystem.squashfs/var/lib/python-support/python2.6/rdflib/store/REGEXMatching.pyc

Python Compiled Bytecode | 2009-04-20 | 6.9 KB | 175 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

"""
This wrapper intercepts calls through the store interface which  make use of
The REGEXTerm class to represent matches by REGEX instead of literal comparison
Implemented for stores that don't support this and essentially provides the support
by replacing the REGEXTerms by wildcards (None) and matching against the results
from the store it's wrapping
"""
from rdflib.store import Store
from pprint import pprint
from rdflib.Graph import Graph, QuotedGraph, ConjunctiveGraph, BackwardCompatGraph
import re
NATIVE_REGEX = 0
PYTHON_REGEX = 1

class REGEXTerm(unicode):

    def __init__(self, expr):
        self.compiledExpr = re.compile(expr)


    def __reduce__(self):
        return (REGEXTerm, (unicode(''),))



def regexCompareQuad(quad, regexQuad):
    for index in range(4):
        if isinstance(regexQuad[index], REGEXTerm) and not regexQuad[index].compiledExpr.match(quad[index]):
            return False

    return True


class REGEXMatching(Store):

    def __init__(self, storage):
        self.storage = storage
        self.context_aware = storage.context_aware
        self.formula_aware = storage.formula_aware
        self.transaction_aware = storage.transaction_aware


    def open(self, configuration, create = True):
        return self.storage.open(configuration, create)


    def close(self, commit_pending_transaction = False):
        self.storage.close()


    def destroy(self, configuration):
        self.storage.destroy(configuration)


    def add(self, .1, context, quoted = False):
        (subject, predicate, object_) = .1
        self.storage.add((subject, predicate, object_), context, quoted)


    def remove(self, .1, context = None):
        (subject, predicate, object_) = .1
        if (isinstance(subject, REGEXTerm) and isinstance(predicate, REGEXTerm) and isinstance(object_, REGEXTerm) or context is not None) and isinstance(context.identifier, REGEXTerm):
            if not not isinstance(subject, REGEXTerm) or subject:
                pass
            s = None
            if not not isinstance(predicate, REGEXTerm) or predicate:
                pass
            p = None
            if not not isinstance(object_, REGEXTerm) or object_:
                pass
            o = None
            if not context is not None or not isinstance(context.identifier, REGEXTerm) or context:
                pass
            c = None
            removeQuadList = []
            for s1, p1, o1 in self.storage.triples((s, p, o), c):
                cg = None
                for ctx in cg:
                    ctx = ctx.identifier
                    if not context is not None or context.identifier:
                        pass
                    if regexCompareQuad((s1, p1, o1, ctx), (subject, predicate, object_, context)):
                        removeQuadList.append((s1, p1, o1, ctx))
                        continue


            for s, p, o, c in removeQuadList:
                if not c or Graph(self, c):
                    pass
                self.storage.remove((s, p, o), c)

        else:
            self.storage.remove((subject, predicate, object_), context)


    def triples(self, .1, context = None):
        (subject, predicate, object_) = .1
        if (isinstance(subject, REGEXTerm) and isinstance(predicate, REGEXTerm) and isinstance(object_, REGEXTerm) or context is not None) and isinstance(context.identifier, REGEXTerm):
            if not not isinstance(subject, REGEXTerm) or subject:
                pass
            s = None
            if not not isinstance(predicate, REGEXTerm) or predicate:
                pass
            p = None
            if not not isinstance(object_, REGEXTerm) or object_:
                pass
            o = None
            if not context is not None or not isinstance(context.identifier, REGEXTerm) or context:
                pass
            c = None
            for s1, p1, o1 in self.storage.triples((s, p, o), c):
                cg = None
                matchingCtxs = []
                for ctx in cg:
                    if c is None:
                        if context is None or context.identifier.compiledExpr.match(ctx.identifier):
                            matchingCtxs.append(ctx)

                    context.identifier.compiledExpr.match(ctx.identifier)
                    matchingCtxs.append(ctx)

                if matchingCtxs and regexCompareQuad((s1, p1, o1, None), (subject, predicate, object_, None)):
                    yield ((s1, p1, o1), (lambda .0: for c in .0:
c)(matchingCtxs))
                    continue

        else:
            for s1, p1, o1 in self.storage.triples((subject, predicate, object_), context):
                cg = None
                yield ((s1, p1, o1), cg)



    def __len__(self, context = None):
        return self.storage.__len__(context)


    def contexts(self, triple = None):
        for ctx in self.storage.contexts(triple):
            yield ctx



    def remove_context(self, identifier):
        self.storage.remove((None, None, None), identifier)


    def bind(self, prefix, namespace):
        self.storage.bind(prefix, namespace)


    def prefix(self, namespace):
        return self.storage.prefix(namespace)


    def namespace(self, prefix):
        return self.storage.namespace(prefix)


    def namespaces(self):
        return self.storage.namespaces()


    def commit(self):
        self.storage.commit()


    def rollback(self):
        self.storage.rollback()